<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
<meta name="author" content="">
<meta name="description" content="Go内存模型明确指出，一个goroutine如何才能观察到其他goroutine对同一变量的写操作。
当多个goroutine并发同时存取同一个数据时必须把并发的存取操作序列化。在Go中保证读写的序列化可以通过channel通信或者其他同步原语（例如sync包中的互斥锁、读写锁和sync/atomic中的原子操作）。
Happens Before 在单goroutine中，读取和写入的行为一定是和程序指定的执行顺序表现一致。换言之，编译器和处理器在不改变语言规范所定义的行为前提下才可以对单个goroutine中的指令进行重排序。
a := 1 b := 2 由于指令重排序，b := 2可能先于a := 1执行。单goroutine中，该执行顺序的调整并不会影响最终结果。但多个goroutine场景下可能就会出现问题。
var a, b int // goroutine A go func() { a := 5 b := 1 }() // goroutine B go func() { for b == 1 {} fmt.Println(a) }() 执行上述代码时，预期goroutine B能够正常输出5，但因为指令重排序，b := 1可能先于a := 5执行，最终goroutine B可能输出0。
 注：上述例子是个不正确的示例，仅作说明用。
 为了明确读写的操作的要求，Go中引入了happens before，它表示执行内存操作的一种偏序关系。
happens-before的作用 多个goroutine访问共享变量时，它们必须建立同步事件来确保happens-before条件，以此确保读能够观察预期的写。
什么是Happens Before 如果事件e1发生在事件e2之前，那么我们说e2发生在e1之后。 同样，如果e1不在e2之前发生也没有在e2之后发生，那么我们说e1和e2同时发生。
在单个goroutine中，happens-before的顺序就是程序执行的顺序。那happens-before到底是什么顺序呢？我们看看下面的条件。
如果对于一个变量v的读操作r和写操作w满足下述两个条件，r才允许观察到w：
 r没有发生在w之前。 没有其他写操作发生在w之后和r之前。  为了保证变量v的一个读操作r能够观察到一个特定的写操作w，需要确保w是唯一允许被r观察的写操作。那么，如果 r、w 都满足以下条件，r就能确保观察到w：" />
<meta name="keywords" content=", Go" />
<meta name="robots" content="noodp" />
<meta name="theme-color" content="" />
<link rel="canonical" href="https://gopher-north.gitee.io/timeline/go-memory-model/" />


    <title>
        
            白话Go内存模型&amp;Happen-Before :: Gopher指北 
        
    </title>



<link href="https://cdnjs.cloudflare.com/ajax/libs/flag-icon-css/3.2.1/css/flag-icon.min.css" rel="stylesheet"
    type="text/css"> 




<link rel="stylesheet" href="/main.805b1025016494ee5fd67b55b8ecd5e2b7c4a9f0bdda42e300c62b85ddfef68f.css">


  

    <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">
    <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">
    <link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png">
    <link rel="manifest" href="/site.webmanifest">
    <link rel="mask-icon" href="/safari-pinned-tab.svg" color="#252627">
    <link rel="shortcut icon" href="/favicon.ico">
    <meta name="msapplication-TileColor" content="#252627">
    <meta name="theme-color" content="#252627">



<meta itemprop="name" content="白话Go内存模型&amp;Happen-Before">
<meta itemprop="description" content="Go内存模型明确指出，一个goroutine如何才能观察到其他goroutine对同一变量的写操作。
当多个goroutine并发同时存取同一个数据时必须把并发的存取操作序列化。在Go中保证读写的序列化可以通过channel通信或者其他同步原语（例如sync包中的互斥锁、读写锁和sync/atomic中的原子操作）。
Happens Before 在单goroutine中，读取和写入的行为一定是和程序指定的执行顺序表现一致。换言之，编译器和处理器在不改变语言规范所定义的行为前提下才可以对单个goroutine中的指令进行重排序。
a := 1 b := 2 由于指令重排序，b := 2可能先于a := 1执行。单goroutine中，该执行顺序的调整并不会影响最终结果。但多个goroutine场景下可能就会出现问题。
var a, b int // goroutine A go func() { a := 5 b := 1 }() // goroutine B go func() { for b == 1 {} fmt.Println(a) }() 执行上述代码时，预期goroutine B能够正常输出5，但因为指令重排序，b := 1可能先于a := 5执行，最终goroutine B可能输出0。
 注：上述例子是个不正确的示例，仅作说明用。
 为了明确读写的操作的要求，Go中引入了happens before，它表示执行内存操作的一种偏序关系。
happens-before的作用 多个goroutine访问共享变量时，它们必须建立同步事件来确保happens-before条件，以此确保读能够观察预期的写。
什么是Happens Before 如果事件e1发生在事件e2之前，那么我们说e2发生在e1之后。 同样，如果e1不在e2之前发生也没有在e2之后发生，那么我们说e1和e2同时发生。
在单个goroutine中，happens-before的顺序就是程序执行的顺序。那happens-before到底是什么顺序呢？我们看看下面的条件。
如果对于一个变量v的读操作r和写操作w满足下述两个条件，r才允许观察到w：
 r没有发生在w之前。 没有其他写操作发生在w之后和r之前。  为了保证变量v的一个读操作r能够观察到一个特定的写操作w，需要确保w是唯一允许被r观察的写操作。那么，如果 r、w 都满足以下条件，r就能确保观察到w：">
<meta itemprop="datePublished" content="2021-03-04T18:53:38+08:00" />
<meta itemprop="dateModified" content="2021-03-04T18:53:38+08:00" />
<meta itemprop="wordCount" content="206">



<meta itemprop="keywords" content="Go," />

<meta name="twitter:card" content="summary"/>
<meta name="twitter:title" content="白话Go内存模型&amp;Happen-Before"/>
<meta name="twitter:description" content="Go内存模型明确指出，一个goroutine如何才能观察到其他goroutine对同一变量的写操作。
当多个goroutine并发同时存取同一个数据时必须把并发的存取操作序列化。在Go中保证读写的序列化可以通过channel通信或者其他同步原语（例如sync包中的互斥锁、读写锁和sync/atomic中的原子操作）。
Happens Before 在单goroutine中，读取和写入的行为一定是和程序指定的执行顺序表现一致。换言之，编译器和处理器在不改变语言规范所定义的行为前提下才可以对单个goroutine中的指令进行重排序。
a := 1 b := 2 由于指令重排序，b := 2可能先于a := 1执行。单goroutine中，该执行顺序的调整并不会影响最终结果。但多个goroutine场景下可能就会出现问题。
var a, b int // goroutine A go func() { a := 5 b := 1 }() // goroutine B go func() { for b == 1 {} fmt.Println(a) }() 执行上述代码时，预期goroutine B能够正常输出5，但因为指令重排序，b := 1可能先于a := 5执行，最终goroutine B可能输出0。
 注：上述例子是个不正确的示例，仅作说明用。
 为了明确读写的操作的要求，Go中引入了happens before，它表示执行内存操作的一种偏序关系。
happens-before的作用 多个goroutine访问共享变量时，它们必须建立同步事件来确保happens-before条件，以此确保读能够观察预期的写。
什么是Happens Before 如果事件e1发生在事件e2之前，那么我们说e2发生在e1之后。 同样，如果e1不在e2之前发生也没有在e2之后发生，那么我们说e1和e2同时发生。
在单个goroutine中，happens-before的顺序就是程序执行的顺序。那happens-before到底是什么顺序呢？我们看看下面的条件。
如果对于一个变量v的读操作r和写操作w满足下述两个条件，r才允许观察到w：
 r没有发生在w之前。 没有其他写操作发生在w之后和r之前。  为了保证变量v的一个读操作r能够观察到一个特定的写操作w，需要确保w是唯一允许被r观察的写操作。那么，如果 r、w 都满足以下条件，r就能确保观察到w："/>







    <meta property="article:published_time" content="2021-03-04 18:53:38 &#43;0800 CST" />








    </head>

    <body class="">
        <div class="container">
            <header class="header">
    <span class="header__inner">
        <a href="https://gopher-north.gitee.io/" style="text-decoration: none;">
    <div class="logo">
        
            <span class="logo__mark">Gopher指北</span>
            <span class="logo__text"></span>
            <span class="logo__cursor" style=
                  "
                   
                   ">
            </span>
        
    </div>
</a>


        <span class="header__right">
             
            <span class="theme-toggle unselectable"><svg class="theme-toggler" width="24" height="24" viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg">
  <path d="M22 41C32.4934 41 41 32.4934 41 22C41 11.5066 32.4934 3 22
  3C11.5066 3 3 11.5066 3 22C3 32.4934 11.5066 41 22 41ZM7 22C7
  13.7157 13.7157 7 22 7V37C13.7157 37 7 30.2843 7 22Z"/>
</svg>
</span>
        </span>
    </span>
</header>


            <div class="content">
                
  <main class="post">

    <div class="post-info">
      <p>
        <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-clock">
          <circle cx="12" cy="12" r="10"></circle>
          <polyline points="12 6 12 12 16 14"></polyline>
        </svg>
        One minute

        
      </p>
    </div>

    <article>
      <h1 class="post-title">
        <a href="https://gopher-north.gitee.io/timeline/go-memory-model/">白话Go内存模型&amp;Happen-Before</a>
      </h1>
        <hr />
        <aside id="toc">
          <div class="toc-title">Table of Contents</div>
          <nav id="TableOfContents">
  <ul>
    <li><a href="#happens-before的作用">happens-before的作用</a></li>
    <li><a href="#什么是happens-before">什么是Happens Before</a></li>
  </ul>

  <ul>
    <li><a href="#go的初始化">Go的初始化</a></li>
    <li><a href="#goroutine的创建结束">goroutine的创建结束</a></li>
    <li><a href="#channel的发送和接收">Channel的发送和接收</a></li>
    <li><a href="#lock">Lock</a></li>
    <li><a href="#once">Once</a></li>
  </ul>
</nav>
        </aside>
        <hr />

      

      <div class="post-content">
        <p>Go内存模型明确指出，一个goroutine如何才能观察到其他goroutine对同一变量的写操作。</p>
<p>当多个goroutine并发同时存取同一个数据时必须把并发的存取操作序列化。在Go中保证读写的序列化可以通过channel通信或者其他同步原语（例如sync包中的互斥锁、读写锁和sync/atomic中的原子操作）。</p>
<h1 id="happens-before">Happens Before</h1>
<p>在单goroutine中，读取和写入的行为一定是和程序指定的执行顺序表现一致。换言之，编译器和处理器在不改变语言规范所定义的行为前提下才可以对单个goroutine中的指令进行重排序。</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-go" data-lang="go"><span style="color:#a6e22e">a</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">1</span>
<span style="color:#a6e22e">b</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">2</span>
</code></pre></div><p>由于指令重排序，<code>b := 2</code>可能先于<code>a := 1</code>执行。单goroutine中，该执行顺序的调整并不会影响最终结果。但多个goroutine场景下可能就会出现问题。</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-go" data-lang="go"><span style="color:#66d9ef">var</span> <span style="color:#a6e22e">a</span>, <span style="color:#a6e22e">b</span> <span style="color:#66d9ef">int</span>
<span style="color:#75715e">// goroutine A
</span><span style="color:#75715e"></span><span style="color:#66d9ef">go</span> <span style="color:#66d9ef">func</span>() {
    <span style="color:#a6e22e">a</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">5</span>
    <span style="color:#a6e22e">b</span> <span style="color:#f92672">:=</span> <span style="color:#ae81ff">1</span>
}()
<span style="color:#75715e">// goroutine B
</span><span style="color:#75715e"></span><span style="color:#66d9ef">go</span> <span style="color:#66d9ef">func</span>() {
    <span style="color:#66d9ef">for</span> <span style="color:#a6e22e">b</span> <span style="color:#f92672">==</span> <span style="color:#ae81ff">1</span> {}
    <span style="color:#a6e22e">fmt</span>.<span style="color:#a6e22e">Println</span>(<span style="color:#a6e22e">a</span>)
}()
</code></pre></div><p>执行上述代码时，预期goroutine B能够正常输出5，但因为指令重排序，<code>b := 1</code>可能先于<code>a := 5</code>执行，最终goroutine B可能输出0。</p>
<blockquote>
<p><strong>注</strong>：上述例子是个不正确的示例，仅作说明用。</p>
</blockquote>
<p>为了明确读写的操作的要求，Go中引入了<code>happens before</code>，它表示执行内存操作的一种偏序关系。</p>
<h2 id="happens-before的作用">happens-before的作用</h2>
<p>多个goroutine访问共享变量时，它们必须建立同步事件来确保happens-before条件，以此确保读能够观察预期的写。</p>
<h2 id="什么是happens-before">什么是Happens Before</h2>
<p>如果事件e1发生在事件e2之前，那么我们说e2发生在e1之后。 同样，如果e1不在e2之前发生也没有在e2之后发生，那么我们说e1和e2同时发生。</p>
<p>在单个goroutine中，happens-before的顺序就是程序执行的顺序。那happens-before到底是什么顺序呢？我们看看下面的条件。</p>
<p>如果对于一个变量v的读操作r和写操作w满足下述两个条件，r才<strong>允许</strong>观察到w：</p>
<ol>
<li>r没有发生在w之前。</li>
<li>没有其他写操作发生在w之后和r之前。</li>
</ol>
<p>为了保证变量v的一个读操作r能够观察到一个特定的写操作w，需要确保w是唯一允许被r观察的写操作。那么，如果 r、w 都满足以下条件，r就能<strong>确保</strong>观察到w：</p>
<ol>
<li>w发生在r之前。</li>
<li>其他写操作发生在w之前后者r之后。</li>
</ol>
<p>单goroutine中不存在并发，这两个条件是等价的。老许在此基础上扩展一下，对于单核心的运行环境这两组条件同样等价。并发情况下，后一组条件比第一组更加严格。</p>
<p>假如你很疑惑，那就对了！老许最开始也很疑惑，这两组条件就是一样的呀。为此老许特地和原文进行了反复对比确保上述的理解是没有问题的。</p>
<p><img src="https://note.youdao.com/yws/api/personal/file/WEBebd7cd55c1ff407b05900807355c9010?method=download&amp;shareKey=91b03f6fdf992ed04c06d873219e3725" alt=""></p>
<p>我们换个思路，进行反向推理。如果这两组条件一样，那原文没必要写两次，果然此事并不简单。</p>
<p><img src="https://note.youdao.com/yws/api/personal/file/WEB9ef1aa573f52434032ce40c6d525509f?method=download&amp;shareKey=464df8124d6c3a538a5f20189d68890c" alt=""></p>
<p>在继续分析之前，要先感谢一下我的语文老师，没有你我就无法发现它们的不同。</p>
<p><code>r没有发生在w之前</code>，则r可能的情况是r发生在w之后或者和w同时发生，如下图（实心表示可同时）。</p>
<p><img src="https://note.youdao.com/yws/api/personal/file/WEB9d6ef4da5ed351b7be9714404cea7a16?method=download&amp;shareKey=535d89b4786491f6b3ae27f7527b34bf" alt=""></p>
<p><code>没有其他写操作发生在w之后和r之前</code>，则其他写w&rsquo;可能发生在w之前或者和w同时发生，也可能发生在r之后或者和r同时发生，如下图（实心表示可同时）。</p>
<p><img src="https://note.youdao.com/yws/api/personal/file/WEBb31fc5b4f9b84711a39f34270bd4eca1?method=download&amp;shareKey=7cb5b00eca87f4552676665227d2ccd5" alt=""></p>
<p>第二组条件就很明确了，w发生在r之前且其他写操作只能发生在w之前或者r之后，如下图（空心表示不可同时）。</p>
<p><img src="https://note.youdao.com/yws/api/personal/file/WEBcd7396985d35dba916d914f9139d2ca0?method=download&amp;shareKey=bcaa56ab18dd267da16c10431ddad674" alt=""></p>
<p>到这儿应该明白为什么第二组条件比第一组条件更加严格了吧。在第一组的条件下是允许观察到w，第二组是保证能观察到w。</p>
<h1 id="go中的同步">Go中的同步</h1>
<p>下面是Go中约定好的一些同步事件，它们能确保程序遵循happens-before原则，从而使并发的goroutine相对有序。</p>
<h2 id="go的初始化">Go的初始化</h2>
<p>程序初始化运行在单个goroutine中，但是该goroutine可以创建其他并发运行的goroutine。</p>
<p>如果包p导入了包q，则q包init函数执行结束先于p包init函数的执行。main函数的执行发生在所有init函数执行完成之后。</p>
<h2 id="goroutine的创建结束">goroutine的创建结束</h2>
<p>goroutine的创建先于goroutine的执行。老许觉得这基本就是废话，但事情总是没有那么简单，其隐含之意大概是goroutine的创建是阻塞的。</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-go" data-lang="go"><span style="color:#66d9ef">func</span> <span style="color:#a6e22e">sleep</span>() <span style="color:#66d9ef">bool</span> {
   <span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">Sleep</span>(<span style="color:#a6e22e">time</span>.<span style="color:#a6e22e">Second</span>)
   <span style="color:#66d9ef">return</span> <span style="color:#66d9ef">true</span>
}

<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">fmt</span>.<span style="color:#a6e22e">Println</span>(<span style="color:#a6e22e">sleep</span>())
</code></pre></div><p>上述代码会阻塞主goroutine一秒，然后才创建子goroutine。</p>
<p>goroutine的退出是无法预测的。如果用一个goroutine观察另一个goroutine，请使用锁或者Channel来保证相对有序。</p>
<h2 id="channel的发送和接收">Channel的发送和接收</h2>
<p>Channel通信是goroutine之间同步的主要方式。</p>
<ul>
<li>
<p>Channel的发送动作先于相应的接受动作完成之前。</p>
</li>
<li>
<p>无缓冲Channel的接受先于该Channel上的发送完成之前。</p>
</li>
</ul>
<p>这两点总结起来分别是<code>开始发送</code>、<code>开始接受</code>、<code>发送完成</code>和<code>接受完成</code>四个动作，其时序关系如下。</p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-shell" data-lang="shell">开始发送 &gt; 接受完成
开始接受 &gt; 发送完成
</code></pre></div><blockquote>
<p>注意：开始发送和开始接受并无明确的先后关系</p>
</blockquote>
<ul>
<li>
<p>Channel的关闭发生在由于通道关闭而返回零值接受之前。</p>
</li>
<li>
<p>容量为C的Channel第k个接受先于该Channel上的第k+C个发送完成之前。</p>
</li>
</ul>
<p>这里使用极限法应该更加易于理解，如果C为0，k为1则其含义和无缓冲Channel的一致。</p>
<h2 id="lock">Lock</h2>
<p>对于任何sync.Mutex或sync.RWMutex变量l以及n &lt; m，第n次l.Unlock()的调用先于第m次l.Lock()的调用返回。</p>
<p>假设n为1，m为2，则第二次调用l.Lock()返回前一定要先调用l.UnLock()。</p>
<p>对于sync.RWMutex的变量l存在这样一个n，使得l.RLock()的调用返回在第n次l.Unlock()之后发生，而与之匹配的l.RUnlock()发生在第n + 1次l.Lock()之前。</p>
<p>不得不说，上面这句话简直不是人能理解的。老许将其翻译成人话：</p>
<p>有写锁时：l.RLock()的调用返回发生在l.Unlock()之后。</p>
<p>有读锁时：l.RUnlock()的调用发生在l.Lock()之前。</p>
<blockquote>
<p>注意：调用l.RUnlock()前不调用l.RLock()和调用l.Unlock()前不调用l.Lock()会引起panic。</p>
</blockquote>
<h2 id="once">Once</h2>
<p>once.Do(f)中f的返回先于任意其他once.Do的返回。</p>
<h1 id="不正确的同步">不正确的同步</h1>
<p><strong>错误示范一</strong></p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-go" data-lang="go"><span style="color:#66d9ef">var</span> <span style="color:#a6e22e">a</span>, <span style="color:#a6e22e">b</span> <span style="color:#66d9ef">int</span>

<span style="color:#66d9ef">func</span> <span style="color:#a6e22e">f</span>() {
	<span style="color:#a6e22e">a</span> = <span style="color:#ae81ff">1</span>
	<span style="color:#a6e22e">b</span> = <span style="color:#ae81ff">2</span>
}

<span style="color:#66d9ef">func</span> <span style="color:#a6e22e">g</span>() {
	print(<span style="color:#a6e22e">b</span>)
	print(<span style="color:#a6e22e">a</span>)
}

<span style="color:#66d9ef">func</span> <span style="color:#a6e22e">main</span>() {
	<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">f</span>()
	<span style="color:#a6e22e">g</span>()
}
</code></pre></div><p>这个例子看起来挺简单，但是老许相信大部分人应该会忽略指令重排序引起的异常输出。假如goroutine f指令重排序后，<code>b=2</code>先于<code>a=1</code>发生，此时主goroutine观察到b发生变化而未观察到a变化，因此有可能输出<code>20</code>。</p>
<blockquote>
<p>老许在本地实验了多次结果都是输出<code>00</code>，<code>20</code>这个输出估计只活在理论之中了。</p>
</blockquote>
<p><strong>错误示范二</strong></p>
<div class="highlight"><pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-go" data-lang="go"><span style="color:#66d9ef">var</span> <span style="color:#a6e22e">a</span> <span style="color:#66d9ef">string</span>
<span style="color:#66d9ef">var</span> <span style="color:#a6e22e">done</span> <span style="color:#66d9ef">bool</span>

<span style="color:#66d9ef">func</span> <span style="color:#a6e22e">setup</span>() {
	<span style="color:#a6e22e">a</span> = <span style="color:#e6db74">&#34;hello, world&#34;</span>
	<span style="color:#a6e22e">done</span> = <span style="color:#66d9ef">true</span>
}

<span style="color:#66d9ef">func</span> <span style="color:#a6e22e">doprint</span>() {
	<span style="color:#66d9ef">if</span> !<span style="color:#a6e22e">done</span> {
		<span style="color:#a6e22e">once</span>.<span style="color:#a6e22e">Do</span>(<span style="color:#a6e22e">setup</span>)
	}
	print(<span style="color:#a6e22e">a</span>)
}

<span style="color:#66d9ef">func</span> <span style="color:#a6e22e">twoprint</span>() {
	<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">doprint</span>()
	<span style="color:#66d9ef">go</span> <span style="color:#a6e22e">doprint</span>()
}
</code></pre></div><p>这种双重检测本意是为了避免同步的开销，但是依旧有可能打印出空字符串而不是“hello, world”。说实话老许自己都不敢保证以前没有写过这样的代码。现在唯一能想到的场景就是其中一个goroutine doprint执行到<code>done = true</code>（指令重排序导致<code>done=true</code>先于<code>a=&quot;hello, world&quot;</code>执行）时，另一个goroutine doprint刚开始执行并观察到done的值为true从而打印空字符串。</p>
<p>最后，衷心希望本文能够对各位读者有一定的帮助。当然，发现错误也还请及时联系老许改正。</p>
<p><strong>参考</strong></p>
<p><a href="https://golang.org/ref/mem">https://golang.org/ref/mem</a></p>
<p>【关注公众号】</p>
<p><img src="https://note.youdao.com/yws/api/personal/file/WEBa3ee67b2b867e98cb5c587f4adfa6801?method=download&amp;shareKey=0fbb95d0aec6170b854e7b890d50d559" alt=""></p>

      </div>
    </article>

    <hr />

    <div class="post-info">
        <p>
          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-tag meta-icon">
            <path d="M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z"></path>
            <line x1="7" y1="7" x2="7" y2="7"></line>
          </svg><span class="tag"><a href="https://gopher-north.gitee.io/tags/go/">Go</a></span>
        </p>

      <p>
        <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-file-text">
          <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path>
          <polyline points="14 2 14 8 20 8"></polyline>
          <line x1="16" y1="13" x2="8" y2="13"></line>
          <line x1="16" y1="17" x2="8" y2="17"></line>
          <polyline points="10 9 9 9 8 9"></polyline>
        </svg>
        206 Words
      </p>

      <p>
        <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-calendar">
          <rect x="3" y="4" width="18" height="18" rx="2" ry="2"></rect>
          <line x1="16" y1="2" x2="16" y2="6"></line>
          <line x1="8" y1="2" x2="8" y2="6"></line>
          <line x1="3" y1="10" x2="21" y2="10"></line>
        </svg>
        2021-03-04 18:53 &#43;0800
      </p>
 
    </div>

    
      <div class="pagination">
        <div class="pagination__title">
          <span class="pagination__title-h"></span>
          <hr />
        </div>

        <div class="pagination__buttons">
          
            <span class="button previous">
              <a href="https://gopher-north.gitee.io/timeline/get-full-url/">
                <span class="button__icon">←</span>
                <span class="button__text">有趣！一行代码居然无法获取请求的完整URL</span>
              </a>
            </span>
          

          
            <span class="button next">
              <a href="https://gopher-north.gitee.io/timeline/60-linux/">
                <span class="button__text">1分钟内的Linux性能分析法</span>
                <span class="button__icon">→</span>
              </a>
            </span>
          
        </div>
      </div>
    


    

  </main>

            </div>

            
                <footer class="footer">
    <div class="footer__inner">
        <div class="footer__content">
            <span>&copy; 2021</span>
            
             
        </div>
    </div> 
</footer>
<script type="text/javascript">
    $(function(){

  window.sr = ScrollReveal();

  if ($(window).width() < 768) {

    if ($('.timeline-content').hasClass('js--fadeInLeft')) {
        $('.timeline-content').removeClass('js--fadeInLeft').addClass('js--fadeInRight');
    }

    sr.reveal('.js--fadeInRight', {
        origin: 'right',
        distance: '300px',
        easing: 'ease-in-out',
        duration: 800,
      });

  } else {
    
    sr.reveal('.js--fadeInLeft', {
        origin: 'left',
        distance: '300px',
          easing: 'ease-in-out',
        duration: 800,
      });

      sr.reveal('.js--fadeInRight', {
        origin: 'right',
        distance: '300px',
        easing: 'ease-in-out',
        duration: 800,
      });

  }
  
  sr.reveal('.js--fadeInLeft', {
        origin: 'left',
        distance: '300px',
          easing: 'ease-in-out',
        duration: 800,
      });

      sr.reveal('.js--fadeInRight', {
        origin: 'right',
        distance: '300px',
        easing: 'ease-in-out',
        duration: 800,
      });


});

</script>
            
        </div>

        




<script type="text/javascript" src="/bundle.min.dc716e9092c9820b77f96da294d0120aeeb189b5bcea9752309ebea27fd53bbe6b13cffb2aca8ecf32525647ceb7001f76091de4199ac5a3caa432c070247f5b.js" integrity="sha512-3HFukJLJggt3&#43;W2ilNASCu6xibW86pdSMJ6&#43;on/VO75rE8/7KsqOzzJSVkfOtwAfdgkd5BmaxaPKpDLAcCR/Ww=="></script>


    
        <script src="/js/bd-hm.js"></script>
    


    </body>
</html>
